// 声明一个接口 用来限制输入值的类型
// interface Person {
//     firstName: string;
//     lastName: string;
// }
//
// // 限制这个函数输入值的类型 必须是 Person接口中定义的类型
// function greeter(person: Person) {
//     return "Hello, " + person.firstName + " " + person.lastName;
// }
//
//
// class Student {
//     fullName: string;
//
//     constructor(public firstName: string, public middleInitial: string, public lastName: string) {
//         this.fullName = firstName + " " + middleInitial + " " + lastName;
//     }
// }
//
// let user = new Student("Jane", "M.", "User");
//
// greeter(user);
//
// // 限制输入值的类型
// interface UserInterface {
//     currentPage: number,
//     pageSize: number,
//     username?: string
// }
//
// // 写一个方法，需要传入一个 当前页 每页的条数 搜索条件等进行查询
// class Users {
//     constructor(public currentPage: number, public pageSize: number, public username: string) {
//         this.currentPage = currentPage;
//         this.pageSize = pageSize;
//         this.username = username;
//     }
// }

// function getUserListAndSearchByUser(users: UserInterface) {
//     return "成功";
// }
//
// let users = new Users(1, 10, '');
// getUserListAndSearchByUser(users)
//
//
// // TypeScript中有各种基本数据类型
// // 有字符串 布尔 数组  元组 枚举 任意值 空值  null和undefined  Never 类型断言
// // 布尔
// let isDone: boolean = true
// //字符串
// let username: string = 'admin'
// // 数字
// let age: number = 23
// 数组
// 第一种形式
// let ages: number[] = [23, 35, 45]
// let names: string [] = ['kun', 'yan']
// // 第二种形式
// let ageArr: Array<number> = [1, 3]
// let nameArr: Array<string> = ['ce', 'de']
// // 元组 就是可以定义多种数据类型
// let x: [number, string] = [1, '2']

// 枚举 默认从0开始
// enum EnumColor {
//     RED,
//     BlUE,
//     PINK
// }

// 获取到的是对应的数字编号
//let c: EnumColor = EnumColor.RED
// 获取到的是枚举的名称
//let colorName: string = EnumColor[0]

// 任意值
// let renyi: any = 'a'
// let renyis: any = 123
// 空值 就是和任意类型相反
//void
//  类型断言  当我定义一个值是 任意类型  我明确的知道他是string类型的  那么这时我就是可以使用类型推断   明确的告诉他是那个类型的
// let someValue: any = 'admin'
// let strLength: number = (<string>someValue).length
// let strLengths: number = (someValue as string).length
//
//
// // 函数类型
// interface SearchFunc {
//     (source: string, subString: string): boolean;
// }
//
//
// let mySearch: SearchFunc = function (source: string, subString: string) {
//     let result = source.search(subString);
//
//     return result > -1;
// }
//
// console.log(mySearch('admin', 'ad'))


// 封装axios
import axios from "axios";

// 请求的方法
// enum Method {
//     GET = 'GET',
//     POST = 'POST',
//     PUT = 'PUT',
//     DELETE = 'DELETE',
//     OPTIONS = 'OPTIONS'
// }

// 这个泛型是传入的值的类型
// function $http(url: string, method: Method, data?: any) {
//     return axios({
//         method: method,
//         baseURL: 'http://localhost:8989',
//         url: url,
//         data
//     });
// }
//
// $http('user/admin', Method.POST);

// 函数类型的接口：对方法传入的参数 以及返回值进行约束

// 加密的函数类型接口
// interface encrypt {
//     (key: string, value: string): string
// }
//
// let md5: encrypt = function (key: string, value: string): string {
//     // 模拟 操作
//     return key + value
// }
//
// md5("clientServe", "serveClient")


// 可索引接口  数组、对象的约束  不常用

// 可索引接口  对数组的约束
// interface UserArr {
//     // 索引值       返回值
//     [index: number]: string
// }
//
// let arr: UserArr = ['a', 'b']
//
//
// // 可索引接口 对对象的约束  了解
// interface UserObject {
//     // 索引是一个字符串  返回值
//     [index: string]: string
// }
//
// let arrObject: UserObject = {names: 'kun'}

// 类类型接口
// interface Animal {
//     name: string
//
//     eat(str: string): void
// }
//
// class Cat implements Animal {
//     name: string
//
//     constructor(name: string) {
//         this.name = name
//     }
//
//     eat(str: string): void {
//         console.log("这个" + str)
//     }
// }
//
// let cat = new Cat('admin')

// 接口的扩展
// interface Animal {
//
//     eat(): void
// }
//
// interface Personss extends Animal {
//     work(): void
// }
//
//
// class Web  implements  Personss{
//
//     private  name:string
//
//     constructor(name:string) {
//         this.name=name
//     }
//
//     eat(): void {
//         console.log("eat")
//     }
//
//     work(): void {
//         console.log("work")
//     }
//
// }

// 泛型就是解决 类  接口 方法 的复用性，以及不特定数据类型的支持
//
// function getData1(value: string): string {
//
//     return "string"
// }
//
// function getData2(value: string): number {
//
//     return 123
// }
//
// function getData3<T>(data: T): T {
//     return data;
// }

// 泛型类

// class Result<T> {
//
//     code: number | undefined
//     message: string | undefined
//     data: T | undefined
//
//     public static success(data: object): Result<any> {
//         let result = new Result<object>();
//         result.code = 200
//         result.message = "处理成功"
//         result.data = data
//         return result;
//     }
// }
//
// function getUserList():Result<any> {
//
//     let numbers = Array.of(1,2,3);
//
//     return  Result.success(numbers)
// }


//console.log(getUserList())

// 泛型接口

// 实现CRUD的封装
// 对应的是数据库表的字段
class Users {
    name: string | undefined
    password: string | undefined
}


interface CRUDInterface<T>{
    add(data: T): void

    delete(id:number): void

    update(data: T): void

    getOne(data: T): T

    list(): Array<T>
}


interface  UserService extends  CRUDInterface<Users>{

}

class UserServiceImpl implements  UserService{
    add(data: Users): void {
        console.log("增加数据")
    }

    delete(id: number): void {
        console.log("删除数据")
    }

    list(): Array<Users> {
        return [];
    }

    getOne(data: Users): Users {
        return new Users();
    }

    update(data: Users): void {
    }

}


class MysqlDb<T> implements CRUDInterface<T> {
    add(data: T): void {
    }

    delete(id: number): void {
    }

    getOne(data: T): T {
        throw  new Error("");
    }

    list(): Array<T> {
        throw  new Error("");
    }

    update(data: T): void {
    }

}






























